13. AJAX: La revolución.


13.1. Introducción. Conceptos básicos. Referencias

Ya que a día de hoy todos hemos oído hablar de AJAX, de la potencia y flexibilidad que nos aporta en nuestras páginas Web, en este capítulo vamos a aclarar todos los conceptos que implica el uso de AJAX así como intentar servir de guía y referencia para el uso y profundización de esta técnica.

La primera pregunta que nos hacemos es ¿Qué es AJAX? El significado estricto es “Asynchronous JavaScript and XML”, es decir, JavaScript asíncrono y XML. Podemos deducir que no es una tecnología en sí, sino una agrupación de tecnologías. Concretamente:

    * XHTML: Encargada del contenido de la información, para profundizar dirígete al capítulo 10.

    * CSS ó hojas de estilo: Utilizadas en la presentación de los contenidos, en el capítulo 11 puedes aprender a usarlas.

    * DOM: Modelo de objetos de documentos, explicado con anterioridad en el capítulo 12.

   * XML, JSON y XSLT: Estos son los formatos utilizados para la transferencia de información, fíjate que podemos utilizar AJAX por ejemplo con JSON si hacer uso de XML.

    * XMLHttpRequest: A esto podríamos denominarlo el núcleo de AJAX, ya que como veremos más adelante, en este mismo epígrafe, es el encargado de comunicarse con el servidor.

    * JavaScript: Es el cemento o la argamasa que nos permite utilizar todas las tecnologías comentadas. Nuestro hilo conductor.

La revolución que ha ocasionado AJAX viene en buena parte determinada por la manera de trabajar de cara al servidor Web. Tradicionalmente cuando estas navegando y solicitas nueva información, envías una petición al servidor que procesa y responde con la nueva página Web que has de recargar.

Con AJAX el funcionamiento varía, ya que creamos una capa intermedia, cuyo elemento principal es el XMLHttpRequest, encargada de gestionar las peticiones del y hacia el servidor. De tal manera que al solicitar nueva información la capa intermedia se encarga de relacionarse con el servidor, generalmente en XML, para posteriormente actualizar sólo las partes de la página que sean necesarias y mientras tanto podemos seguir visualizando y trabajando con la página.


Con AJAX disponemos de una capa intermedia que se encarga de la comunicación con el servidor y nos libera de las peticiones simples; con lo que mejoramos el tiempo de respuesta y nos da la sensación de estar trabajando con una aplicación de escritorio.

Pero no todo es tan maravilloso, el hecho de trabajar de manera asíncrona implica unas desventajas, como es que la URL ó dirección Web de la página modificada no cambie o el mal funcionamiento del botón atrás del propio navegador del usuario. Por tanto, tenemos que ser precavidos a la hora de utilizar estas técnicas.

Nosotros te recomendamos que utilices AJAX en los siguientes supuestos:

    * Autocompletados de los campos de texto en los formularios.

    * Realización de votaciones, encuestas, etc.

    * Cuando la navegación se realice a través de nodos, por ejemplo tipo árbol.

    * Recarga de los campos select, como elegir una provincia y dentro de ella su localidad.

    * Cuando necesites una comunicación rápida.

    * En el filtrado y manipulación de los resultados de búsquedas.

A continuación te ofrecemos un conjunto de links relativos a AJAX para que profundices y dispongas de recursos


Dirección

Descripción

http://www.elrincondeajax.com/index.html

Completo manual con herramientas, ejemplos y vídeos sobre AJAX.

http://www.formatoweb.com.ar/ajax/


Variedad de ejemplos de AJAX para tus páginas Web.

http://www.librosweb.es/

Portal donde encontrarás libros específicos sobre el tema.

http://www.asp.net/ajax/

Página oficial de Microsoft sobre AJAX, obviamente bajo ASP.

http://www.programacionweb.net/


Navega a la sección de cursos y dispondrás de un buen manual sobre AJAX con ejemplos.

http://www.ajaxya.com.ar/

Especializada sólo en AJAX, encontrarás numerosos ejemplos y recursos.


13.2. Análisis de nuestra primera página con AJAX.

Vamos a desarrollar una página con AJAX. Observa las ilustraciones que te mostramos:

En ellas se varía la sección inferior “Elige un libro” dependiendo de la opción superior elegida “Libros publicados” sin necesidad de tener que recargar toda la página.




El código fuente de la página en XHTML/HTML es el que te mostramos a continuación:


<html>

<head>

<title>Mi primer ejemplo en AJAX</title>

<script src="F_JavaScript.js" language="JavaScript"></script>

<link rel="StyleSheet" href="F_estilos.css" type="text/css">

</head>

<body>

<h1>Ejemplo de uso de AJAX </h1>

<div id="Libros">

<p>Libros Publicados.</p>

<p><a id="enlace1" href="ajax1.php?cod=1">¡Pásate a Linux!</a></p>

<p><a id="enlace2" href="ajax1.php?cod=2">¡Aprende en libre!</a></p>

<p><a id="enlace3" href="ajax1.php?cod=3">Guía del perfecto WebMaster</a></p>

</div>

<div id="Info">Elige un libro.</div>

</body>

</html>

Observa que en la cuarta y quinta línea, “<script src="F_JavaScript.js" language="JavaScript"></script> y <link rel="StyleSheet" href="F_estilos.css" type="text/css">” hacemos referencia a dos archivos F_JavaScript.js donde ubicaremos todas las funciones para gestionar la comunicación con el servidor y F_estilos.css donde indicaremos los estilos que vamos a utilizar en la página.


Dispones de los capítulos:

12 para conocer y utilizar el lenguaje JavaScript.

11 para incluir y utilizar hojas de estilo CSS en tus páginas.


El cuerpo de la página contiene dos capas “<div>” “libros e info”. Lo que vamos a realizar en este ejemplo es actualizar la etiqueta info dependiendo del libro seleccionado. Observa que para cada libro hacemos referencia a la página “ajax1.php” pasando el parámetro “cod”. A continuación te exponemos el código fuente de la página “ajax1.php


<?php

header('Content-Type: text/html; charset=ISO-8859-1');

if ($_REQUEST['cod']==1)

{

    echo "<strong>!Pásate a Linux!:</strong>Proporciona los conocimientos básicos y completos para empezar a trabajar con GNU/Linux.";

}

    if ($_REQUEST['cod']==2)

{

    echo "<strong>¡Aprende en Libre!:</strong>Conocimientos y herramientas libres para trabajar, enseñar y/o aprender .";

}

    if ($_REQUEST['cod']==3)

{

    echo "<strong>Guía del perfecto WebMaster:</strong>Todo lo necesario para montar un servidor Web y tener presencia en Internet.";

}

?>


Recuerda que esta página es la que está ubicada en nuestro servidor Web y es la encargada de enviarnos la información que deseamos. El funcionamiento es muy simple, analizamos el código que se nos envía y respondemos con la información relativa al libro elegido mediante la función “echo”.


Al igual que con JavaScript y CSS dispones en este libro de información para aprender el lenguaje php (Hypertext Pre-processor). Dirígete a los capítulos 17 y 18.


Nos quedan por examinar dos ficheros: el de estilos, “F_estilos.css” y el encargado de gestionar todo en “F_funciones.js”. Aquí tienes el código fuente del fichero de hojas de estilo:


#Libros {

  font-family: Arial;

  margin:5px;

}

#Libros p {

  margin:3px;

  padding:3px;

}

#Libros a:hover {

 background-color: #FF6600;

}

#Info {

  background-color:#C0C0C0;

  text-align:Center;

  font-family:Arial;

  margin:5px;

}

Hemos definido cuatro estilos.

Tres para la capa de libros:

* Por defecto, estableciendo el tipo de fuente y el margen.

* Los párrafos, definiendo el margen y el padding.

* Los enlaces, estableciendo que cuando se pase con el ratón por encima de un enlace cambiemos el color de fondo a naranja.

Y un estilo para la capa de información en el que establecemos el color de fondo, alineación del texto, tipo de fuente y el margin.


13.2.1 Entrando en faena: El código en JavaScript.

Hasta aquí todo parece normal, es más, si no dispusiéramos del fichero en JavaScript todo funcionaría correctamente, con la salvedad de que al seleccionar un libro, el servidor nos cargaría en una página nueva la información de éste. ¡Haz la prueba!

Vamos a utilizar AJAX para modificar sólo la sección que nos interesa de la página, la capa “info”. Este es el código fuente del fichero F_funciones.js


// Variable global para el objeto XMLHttpRequest

var Ajax=null;

addEvent(window,'load',inicializarEventos,false);

/**********************************************************************

Función: addEvent

Parámetros: Elemento, objeto que registra el evento

                nomevento, nombre del objeto a registrar

                funcion, funcion a realizar para el evento capturado

                    captura, bubbling=true o capturing=false

Descripción:

Manejador de eventos compatible para todos los navegadores

**********************************************************************/

function addEvent(elemento,nomevento,funcion,captura)

{

    if (elemento.attachEvent)

    {

        elemento.attachEvent('on'+nomevento,funcion);

        return true;

    }

    else

     if (elemento.addEventListener)

    {

        elemento.addEventListener(nomevento,funcion,captura);

      return true;

    }

    else

      return false;

}

/**********************************************************************

Función: Inicializar_Eventos

Parámetros:

Descripción:

Registramos los tres enlaces a los cuales le gestionamos el evento click con la función pulsaste. Hacemos uso de DOM y addEvent

**********************************************************************/

function inicializarEventos()

{

    var objeto_enlace;

    for(contador=1;contador<=3;contador++)
        {

          objeto_enlace=document.getElementById('enlace'+contador);

          addEvent(objeto_enlace,'click',pulsaste,false);
        }

}

/**********************************************************************

Función: Pulsaste

Parámetros: Objeto Event, (¡Para navegadores que cumplen el estándar!)

Descripción:

Construimos la URL del enlace y llamamos a la función MuestraContenido con éste

parámetro. La función es útil para todos los navegadores.

**********************************************************************/

function pulsaste(evento)

{

    if (window.event)

    {

      window.event.returnValue=false;

      var url=window.event.srcElement.getAttribute('href');

      MuestraContenido(url);

    }

else

    if (evento)

    {

      evento.preventDefault();

      var url=evento.target.getAttribute('href');

      MuestraContenido(url);

    }

}

/**********************************************************************

Función: Muestracontenido

Parámetros: URL

Descripción:

Si no recibe el parámetro URL terminamos,

Inicializamos el objeto XMLHttpRequest

Especificamos el procesamiento del resultado del objeto XMLHttpRequest

Enviamos la petición al servidor.

**********************************************************************/

function MuestraContenido(url)

{

    if(url=='')

    {

     return;

    }

    Inicializa();

    Ajax.onreadystatechange = procesarEventos;

    Ajax.open("GET", url, true);

    Ajax.send(null);

}

/**********************************************************************

Función: Inicializa

Parámetros:

Descripción:

Creación del objeto XMLHttpRequest en la variable Ajax.

según sea el navegador una opción u otra

**********************************************************************/

function Inicializa()

{

if (window.ActiveXObject)

{

    Ajax = new ActiveXObject("Microsoft.XMLHTTP");

}

else if (window.XMLHttpRequest)

{

    Ajax = new XMLHttpRequest();

}

return Ajax;

}

/**********************************************************************

Función: ProcesarEventos

Parámetros:

Descripción:

Una vez recibida la información pedida al servidor, actualizamos con la nueva información sólo el elemento que cambia "detalles", dentro de la sección div, el id "info".

**********************************************************************/

function procesarEventos()

{

    var detalles = document.getElementById("Info");

    if(Ajax.readyState == 4 && Ajax.status == 200)

    {

      detalles.innerHTML = Ajax.responseText;

    }

    else

    {

      detalles.innerHTML = "Cargando...";

    }

}


En la primera línea, “var Ajax;” hemos definimos la variable global “Ajax” que será el objeto XMLHttpRequest encargado de la comunicación con el servidor, nos permitirá enviar y recibir información en formato XML (realmente en muchos otros formatos también) y lo crearemos en “Inicializa()”


function Inicializa()

{

  if (window.ActiveXObject)

{

  Ajax = new ActiveXObject("Microsoft.XMLHTTP");

}

  else if (window.XMLHttpRequest)

{

      Ajax = new XMLHttpRequest();

  }

  return Ajax;

}


En esta controlamos el navegador utilizado por el usuario, ya que podemos encontrarnos con navegadores que no siguen los estándares, como por ejemplo Internet Explorer. Concretamente el primer if es específico para estos navegadores.

En la segunda línea “addEvent(window,'load',inicializarEventos,false);” realizamos una llamada a la función addEvent. Esta función la creó el programador Scott Andrew y su función es registrar los eventos producidos según el navegador de que disponga el usuario.


La mayoría de los navegadores utilizan el estándar DOM definido por la W3C como es el caso de Firefox, pero a día de hoy podemos encontrar navegadores con su propio modelo DOM, por ejemplo Microsoft. Es por lo que es necesario controlar el nombre y sintaxis de las funciones.


function addEvent(elemento,nomevento,funcion,captura)

      {

      if (elemento.attachEvent)

      {

          elemento.attachEvent('on'+nomevento,funcion);

      return true;

      }

      else

          if (elemento.addEventListener)

      {

            elemento.addEventListener(nomevento,funcion,captura);

      return true;

      }

      else

          return false;

}


La función recibe cuatro parámetros:

* El primero “elemento” es el objeto que registrará el evento, en nuestro caso “window”.

* Con el segundo especificamos el nombre del evento que deseamos registrar “load”.

* El tercero lo utilizamos para indicar la función que deseamos realizar para el evento. “inicializarEventos”.

* El último lo utilizamos para especificar el flujo de eventos, verdadero para especificar bubbling o capturing.


El flujo de eventos define el orden en que se ejecutan los eventos asociados a los elementos DOM de las páginas Web. Mientras bubbling define el orden partiendo del elemento más específico hasta el menos, capturing utiliza el sistema contrarío, es decir, del menos específico al más específico.


Observa que internamente dependiendo si el navegador del usuario utiliza un manejador de eventos de Microsoft o estándar asociamos el evento con la función attachEvent o addEventListener respectivamente. Fíjate que para los eventos de los navegadores Microsoft hemos de incluir la cadena ‘on’.


Para la correcta compresión del ejemplo, es necesario disponer de conocimientos de JavaScript, si este no es tu caso dispones del capítulo 12 dedicado enteramente a este lenguaje.


Siguiendo el orden lógico la función que utilizamos en addEvent es inicializarEventos. Veamos que realiza:


function inicializarEventos()

{

      var objeto_enlace;

      for(contador=1;contador<=3;contador++)

      {

            objeto_enlace=document.getElementById('enlace'+contador);

            addEvent(objeto_enlace,'click',pulsaste,false);

      }

}


Esta función no recibe ningún parámetro y se encarga de definir un objeto, “objeto_enlace” al cual le registramos el evento ‘clic’ asociándolo a la función “pulsaste” mediante addEvent. Este proceso lo repetimos tantas veces como vínculos “enlace” dispongamos en la página XHTML/HTML, en nuestro caso tres.

Examinemos ahora la función pulsaste:


function pulsaste(evento)

{

    if (window.event)

    {

      window.event.returnValue=false;

 var url = window.event.srcElement.getAttribute('href');

      MuestraContenido(url);

    }

    else

    if (evento)

    {

      evento.preventDefault();

      var url=evento.target.getAttribute('href');

      MuestraContenido(url);

    }

}


Esta función construye la URL, para posteriormente pasarla como parámetro en la función “MuestraContenido”. Otra vez, tenemos que diferenciar entre navegadores que cumplen el estándar y los que no.

Es muy llamativo que a la hora de invocar a la función no utilicemos ningún parámetro y posteriormente aparezca el parámetro “evento” en la cabecera de la misma. Esto se debe a que en los navegadores que cumplen el estándar se crea automáticamente este objeto.


El objeto evento lo utilizamos para transmitir información sobre el evento producido, un ejemplo sería conocer que tecla se ha pulsado.


A continuación te exponemos una tabla con las propiedades para el objeto evento:


Navegadores que cumplen el estándar:

Propiedad

Descripción

event.altKey

Si se pulsó la tecla alt.

event.bubbles 

Indica si el evento pertenece al flujo bubbling.

event.button 

Tecla del ratón.

event.cancelable 

Indica si el evento se puede cancelar.

event.charCode 

Devuelve el código de la tecla pulsada si es carácter.

event.clientX 

Posición horizontal del evento.

event.clientY 

Posición vertical del evento.

event.ctrlKey 

Se pulsó CTRL.

event.currentTarget 

Devuelve una referencia al objeto actual registrado para el evento.

event.detail 

Detalles del evento.

event.eventPhase 

Fase a la que pertenece el evento.

event.isChar 

Obtenemos si la tecla es un carácter.

event.keyCode 

Devuelve el código de la tecla pulsada si no es carácter.

event.layerX

Coordenada horizontal del evento relativo a la capa actual.

event.layerY 

Coordenada vertical del evento relativo a la capa actual.

event.metaKey 

Devuelve verdadero si se pulsó una tecla META.

event.pageX 

Devuelve la coordenada horizontal del evento relativa al documento.

event.pageY

Devuelve la coordenada vertical del evento relativa al documento.

event.relatedTarget 

Objeto secundario para el evento.

event.screenX

Coordenada horizontal del evento en pantalla.

event.screenY 

Coordenada vertical del evento en pantalla.

event.shiftKey 

Se pulsó shift.

event.target 


Devuelve una referencia al objeto en la cual el evento fue originalmente enviado.

event.timeStamp

Momento de creación del evento.

event.type 

Tipo del evento.

event.which

Devuelve el código de la tecla pulsada.

Propiedades específicas para Firefox:

event.explicitOriginalTarget 

El objetivo del evento.

event.originalTarget 

El objetivo principal de un evento, antes de cualquier reapunte.


Para los navegadores que no cumplen el estándar la propiedad se suele denominar con el mismo nombre pero sin anteponer “event.”.

Continuemos con el ejemplo, nos habíamos quedado con la función “MuestraContenido(url)”, este es el código fuente:


function MuestraContenido(url)

{

if(url=='')

    {

        return;

    }

Inicializa();

Ajax.onreadystatechange = procesarEventos;

Ajax.open("GET", url, true);

Ajax.send(null);

}


En esta función comprobamos la URL y procedemos a crear el objeto XMLHttpRequest en la variable Ajax con la función “Inicializa()”. Las siguientes líneas las utilizamos para comunicarnos con el servidor:

* “ Ajax.onreadystatechange = procesarEventos;”. Indicamos que tenemos que realizar al recibir la respuesta del servidor mediante la función “procesar Eventos”.

* “ Ajax.open("GET", url, true);” y “Ajax.send(null);”. Estas dos instrucciones sirven para enviar la petición al servidor, primero la creamos con el método open del objeto y posteriormente la enviamos mediante send.


En el siguiente epígrafe entraremos con más profundidad en el estudio de las propiedades y los métodos del objeto XMLHttpRequest.


Para finalizar la explicación del ejemplo nos queda la función procesarEventos:


function procesarEventos()

{

var detalles = document.getElementById("Info");

if(Ajax.readyState == 4 && Ajax.status == 200)

    {

        detalles.innerHTML = Ajax.responseText;

    }

else

    {

        detalles.innerHTML = "Cargando...";

    }

}


Esta función se encarga de variar el contenido de la capa “Info”. Creamos una variable “detalles” con el valor de la capa y revisamos si hemos obtenido la respuesta completa y correcta del servidor mediante las propiedades readyState y status del objeto XMLHttpRequest. Por último, hacemos uso de la propiedad innerHTML para mostrar el contenido actualizado en la página.


La propiedad innerHTML no forma parte de la especificación W3C pero dada su popularidad, simplicidad y la portabilidad en la mayoría de los navegadores actuales hemos decidido incluirla.


13.3. El objeto XMLHttpRequest: Métodos, propiedades y eventos.

Si has examinado el ejemplo anterior te habrás dado cuenta que para cualquiera que esté interesado en AJAX ha de conocer en profundidad el objeto XMLHttpRequest.

Este objeto es el encargado de gestionar el trafico con el servidor Web, enviando las peticiones oportunas e indicando cómo procesar las respuestas de éste. Podríamos definirlo como el principal elemento de la capa intermedia que creamos entre el servidor y las páginas Web.

A continuación te exponemos una tabla con las distintas propiedades de esto objeto así como una descripción de las mismas:


Propiedad

Descripción

readyState

Estado del objeto, disponemos de los siguientes valores:

* 0: Sin inicializar.

* 1: Cargando.

* 2: Cabeceras recibidas.

* 3: Aunque el usuario puede interactuar con el objeto, no está totalmente cargado.

* 4: Completado.

responseBody

Obtenemos la respuesta del servidor como una matriz de bytes.

responseText

Obtenemos la respuesta del servidor como una cadena de texto.

responseXML

Obtenemos la respuesta del servidor en formato XML.

status

Obtenemos el estado de la petición devuelta por el servidor: 200 (OK, sin problemas), 404, etc.

statusText

Igual que el anterior pero en vez de obtener un número obtenemos la cadena de texto: “OK”, “Objeto no encontrado”, “Error interno del servidor”, etc.


Respecto a los métodos, disponemos de los siguientes:


Métodos

Descripción

abort()

Aborta o finaliza la petición actual.

getAllResponseHeaders()

Obtenemos en una cadena de texto todo el conjunto de cabeceras pedidas al servidor.

getResposeHeader(nombre_cabecera)

Devuelve en una cadena de texto la cabecera pedida.

open (método, URL, sincronía, usuario, clave)

Abre una conexión con el servidor. Los parámetros utilizados son:

* método: Puede ser “GET” o “POST”. Indicamos el tipo de conexión.

* URL: Dirección a la que realizamos la petición.

* sincronía: Valor lógico en el que indicamos si deseamos comunicación síncrona o asíncrona (valor true).

* usuario: Parámetro opcional sólo será necesario en el caso de necesitar proporcionar esta información al servidor.

* clave: al igual que usuario es un parámetro opcional que no lo necesitaremos a no ser que el servidor nos lo exija.

send (datos)

Enviamos los datos al servidor.

setRequestHeader (etiqueta, valor)

Permite establecer el valor de las cabeceras en la petición al servidor.


Para completar el manejo de XMLHttpRequest necesitamos conocer también los eventos de los que disponemos:


Evento

Descripción

onreadystatechange

Evento que se dispara con el cambio del estado.

onabort

Evento que se produce al abortar la petición.

onload

Al completar la carga.

onloadstart

Al iniciar la carga.

onprogress

Evento periódico con información de estado.


13.4. Exprimiendo AJAX con Google Maps.

Un referente de AJAX es sin duda la aplicación Maps de Google con la que podemos visitar cualquier parte del mundo obteniendo una gran variedad de información, mapas, fotos, etc.

Este servicio nos lo ofrece Google de manera gratuita. Actualmente podemos utilizar esta herramienta de dos maneras diferentes: creando nuestros propios mapas en Google Maps y posteriormente exportarlos a nuestra página Web o bien entrando más en profundidad programando con la API (Application Programming Interface) que nos ofrece Google. En los siguientes epígrafes analizaremos ambos métodos.


13.4.1. Construye un mapa para tu Web.



La manera más simple de incluir un mapa en una página Web es utilizar el servicio que nos presta Google.

1.- Dirígete a la página http://maps.google.com

2.- Selecciona el enlace Mis mapas, situado en la parte superior derecha.

3.- Ahora haz clic en Crear un mapa nuevo. Es requisito disponer de una cuenta en Google, si no la tienes ahora es un buen momento.

4.- Nos toca definir el mapa, sitúate donde quieras, tienes todo el globo terráqueo para investigar. Ve añadiendo y editando los elementos que quieras. Dispones de una barra de herramientas en la parte superior del mapa en la que puedes:

* Con el icono de la mano, situarte donde quieras.

* El globito, para añadir marcadores.

* Líneas, para indicar, por ejemplo el recorrido.

* Insertar formas, mediante el polígono.

Cada herramienta dispone de bastantes opciones, observa la ilustración inferior, hemos seleccionado León, vamos a añadir una foto y un comentario.

Para indicar los enlaces a imágenes, ten en cuenta que han de estar ubicadas en el servidor, o en alguna URL pública de Internet, para posteriormente visualizarlas correctamente.

5.- Una vez hayas terminado de editar el mapa, haz clic en Listo.

6.-Ahora vamos a obtener el código fuente para insertarlo en nuestra página. Selecciona Enlazar.

7.- Fíjate en la información que te muestra, puedes enviarla por e-mail o copiar el código HTML que te indica.

8.- Una buena práctica es seleccionar Personalizar y obtener vista previa del mapa que se va a insertar.

9.- Ahora puedes elegir el tamaño del mapa y ajustarlo al diseño de tu página.

10.- Una vez configurado el mapa copia el código y pégalo en tú página, obtendrás un resultado sorprendente.

Recuerda que el mapa utiliza tecnología AJAX y es totalmente funcional. A continuación te mostramos el mapa que hemos realizado.


La etiqueta que utilizamos para insertar los mapas es <iframe> con ella insertamos páginas Web dentro de otras. Su sintaxis básica es:

<iframe width=x height=y src=”url” >Texto</iframe>


13.4.2. Quiero más: Conociendo la API’s de Google.

Para los que deseen más funcionalidad sobre los mapas, Google pone a su disposición la API de maps.

Una API es un conjunto de procedimientos, funciones y métodos para trabajar con un componente software.

Estos son los pasos a seguir para utilizar la API:

1.- Dirígete a la dirección http://code.google.com.

2.-Esta es la página principal para los desarrolladores con productos de Google, no está de más que la examines con detenimiento.

3.- Selecciona el enlace API y herramientas.

4.- Busca en la sección deslizante la API de Google Maps y haz clic.

5.- Dirígete a la página de documentación, en la sección detalles: http://code.google.com/intl/es/apis/maps/documentation/index.html

6.- Para poder utilizar la API necesitamos una clave, que tendremos que incluir en el código fuente de nuestras páginas. Selecciona Solicitud de una clave para el API, situado en la esquina superior izquierda.

7.- Tienes que aceptar las condiciones de uso, marca “He leído y estoy de acuerdo…”.

8.- Índica la URL del sitio Web donde vayas a utilizar los mapas. Para las pruebas en tu servidor local puedes indicar http://127.0.0.1. y pulsa en Generar clave de API.

9.-En la siguiente ilustración te mostramos la pantalla resultante del proceso, en ella disponemos de la información de la clave y un ejemplo de uso.


Para obtener la clave de la API de cualquier servicio de Google es necesario que estemos registrados y contemos con una cuenta.

https://www.google.com/accounts/Login


13.4.2.1. Trabajando con la API de Google Maps.

Ya tenemos todo para empezar a trabajar. La primera prueba que podemos realizar es copiar el código fuente que nos han proporcionado e insertarlo en nuestro servidor Web. Este es el resultado:

Ya tenemos nuestro mapa, aunque tenemos que configurarlo a nuestro gusto, fíjate que puedes arrastrar, alejar, acercar, etc. todo de manera asíncrona mediante AJAX.


13.4.2.2. Inicialización del mapa.

Examinemos el código fuente del que disponemos:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="content-type" content="text/html; charset=utf-8"/>

<title>Google Maps JavaScript API Example</title>

<script src="http://maps.google.com/maps?file=api&amp;v=2&amp;key=TUCLAVE"

type="text/javascript">

</script>

<script type="text/javascript">

//<![CDATA[

function load() {

    if (GBrowserIsCompatible()) {

      var map = new GMap2(document.getElementById("map"));

      map.setCenter(new GLatLng(37.4419, -122.1419), 13);

    }

}

//]]>

</script>

</head>

<body onload="load()" onunload="GUnload()">

<div id="map" style="width:500px;height:300px"></div>

</body>

</html>


Estamos tratando con una página en XHTML, en la que indicamos mediante nuestra clave que vamos a utilizar la API de Maps. La función que carga el mapa es la siguiente:


function load() {

    if (GBrowserIsCompatible()) {

 var map = new GMap2(document.getElementById("map"));

      map.setCenter(new GLatLng(37.4419, -122.1419), 13);

    }

}

Creamos un objeto de la clase GMap2 y posteriormente lo mostramos con el método GLatLng. Esta función recibe como parámetros las coordenadas y el zoom aplicado. Por último centramos el mapa con setCenter.


Vamos a empezar definiendo las coordenadas de nuestro mapa.

Abre tu navegador y carga Google Maps.

http://maps.google.com/.

Sitúate donde desees y haz clic en el enlace Enlazar, ubicado en la esquina superior derecha.

Copia la etiqueta <iframe> que te muestran.

Dentro de esta etiqueta están las coordenadas del mapa que estas visualizando, concretamente en el atributo “ll”. Puedes utilizar también http://itouchmap.com/latlong.html. Cópialas y cámbiaselas a la función GLatLng de tu página.


En el ejemplo mostrado, hemos utilizando específicamente la API de Maps. Actualmente, esta API está integrada con las API AJAX de Google, que es un entorno que permite cargar todos las API de Google para que funcionen juntas, proporcionando un espacio de nombres común para todas las API.

Puedes utilizar una opción u otra, nosotros creemos que esta segunda opción es la mejor ya que supone un avance sustancial en la homogenización.

El código fuente de la página quedaría como te mostramos a continuación:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="content-type" content="text/html; charset=utf-8"/>

<title>Google Maps JavaScript API Example</title>

<script type="text/javascript" src="http://www.google.com/jsapi?key=TUCLAVE"></script>

<script type="text/javascript">

google.load("maps", "2.x"); //Esta instrucción carga la API de Maps

function load()

{

    var map = new google.maps.Map2(document.getElementById("map"));

    map.setCenter(new google.maps.LatLng(40.759025,-73.983736), 13);

}

google.setOnLoadCallback(load);

</script>

</head>

<body onload="load()" onunload="GUnload()">

<div id="map" style="width:800px;height:600px"></div>

</body>

</html>


13.4.2.3. Añadiendo controles.

Para añadir funcionalidad al mapa, la API dispone de varios controles que podemos incluir en nuestro mapa:

* GLargeMapControl: Control grande para alejar o acercar el mapa.

* GSmallMapControl: Como el anterior pero más pequeño.

* GSmallZoomControl: Pequeño control de acercamiento (sin desplazamiento).

* GScaleControl: Escala del mapa.

* GMapTypeControl: Control que permite al usuario seleccionar el tipo de mapa:

    * Mapa.

    * Satélite.

    *Híbrido.

* GHierarchicalMapTypeControl: Selección de botones anidados y elementos de menú para colocar muchos selectores de tipos de mapas.

* GOverviewMapControl: Control que nos proporciona un mapa pequeño en la esquina.


El procedimiento para añadir estos controles es utilizar el método addControl del

objeto GMap2. Veamos como incluir la escala, selección del tipo de mapa y el minimapa en nuestro ejemplo:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="content-type" content="text/html; charset=utf-8"/>

<title>Google Maps JavaScript API Example</title>

<script type="text/javascript" src="http://www.google.com/jsapi?key=TUCLAVE"></script>

<script type="text/javascript">

google.load("maps", "2.x");

// Llama a esta función cuando la página se ha cargado.

function load()

    {

      var map = new google.maps.Map2(document.getElementById("map"));

      map.setCenter(new google.maps.LatLng(40.759025,-73.983736), 13);

/*******Añadiendo Controles**********/

      map.addControl(new GMapTypeControl()); //Tipo de Mapa

      map.addControl(new GLargeMapControl()); //Escala

      map.addControl(new GOverviewMapControl()); //Mini mapa

/************************************/

     }

google.setOnLoadCallback(load);

</script>

</head>

<body onload="load()" onunload="GUnload()">

<div id="map" style="width:800px;height:600px"></div>

</body>

</html>


Si deseas cambiar el tipo de mapa inicial, por ejemplo, a satélite dispones de las siguientes constantes:

* G_NORMAL_MAP: Predeterminada.

* G_SATELLITE_MAP: Satélite.

* G_HYBRID_MAP: Híbrido.

La instrucción a incluir es:

map.setMapType(G_SATELLITE_MAP);


13.4.2.4. Construyendo Marcadores.

Los marcadores permiten referenciar ubicaciones dentro de nuestro mapa. La clase que se encarga de proporcionarnos esta funcionalidad es GLatLng.


var Coordenadas = new GLatLng (longitud, latitud);


Con esta instrucción creamos el objeto Coordenadas en la longitud y latitud especificada. Por otro lado, también necesitamos incluir información relativa al marcador, esto lo realizamos mediante la propiedad title de nuestro objeto Coordenadas. Este es el código fuente:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="content-type" content="text/html; charset=utf-8"/>

<title>Google Maps JavaScript API Example</title>

<script type="text/javascript" src="http://www.google.com/jsapi?key=TUCLAVE"></script>

<script type="text/javascript">

google.load("maps", "2.x");

// Llama a esta función cuando la página se ha cargado.

function load()

    {

        var map = new google.maps.Map2(document.getElementById("map"));

        map.setCenter(new google.maps.LatLng(40.759025,-73.983736), 13);

/*******Añadiendo Controles**********/

        map.addControl(new GMapTypeControl()); //Tipo de Mapa

        map.addControl(new GLargeMapControl()); //Escala

        map.addControl(new GOverviewMapControl()); //Minimapa

/*******Añadiendo Marcadores**********/

         var longitud= 40.759025;

         var latitud = -73.983736

         var Coordenadas = new GLatLng (longitud, latitud);

/*Creamos el marcador invocando al método addOverlay de la clase mapa (Map2) con el argumento un objeto de la clase GMarker */

        map.addOverlay(new GMarker(Coordenadas));

        Coordenadas.title='<b>Nueva York</b><br/><p><img src="imagenes/NuevaYork.jpg" height="400" width="500"><br/> Un viaje estupendo</p>';

/* El método openInfoWindowHtml abre una ventana de información en el punto que se indique. El contenido de la información se indica como texto HTML */

        map.openInfoWindowHtml(map.getCenter(),Coordenadas.title);

/*************************************/

     }

google.setOnLoadCallback(load);

</script>

</head>

<body onload="load()" onunload="GUnload()">

<div id="map" style="width:800px;height:600px"></div>

</body>

</html>

Por supuesto, Google te ofrece mucho más recursos. Por ejemplo, visita http://code.google.com/apis/ajax/playground/ para un buen número de códigos AJAX relativos a búsquedas Web restringidas, APIs de Google Earth y Google Map, blogs, feeds, traducción, etc. Elige en el menú izquierdo la categoría y el ejemplo deseado, en el panel central verás el código AJAX y en el inferior el resultado. Puedes incluso modificar el código del panel central y observar los resultados.


Haz clic en Code Menu, View Full Source (ver el código fuente completo), para disponer del código AJAX completo para poder copiarlo y pegarlo en tu servidor Web, ¡listo para usar! Otra alternativa es utilizar la Google Web Toolkit, disponible en http://code.google.com/intl/es/webtoolkit/ que permite crear y mantener componentes AJAX mediante Java, evitando así el proceso tedioso de escribir y mantener un código dependiente de las particularidades de los distintos navegadores.


13.5. Recursos para trabajar con las API’s de Google.

Somos conscientes de que se han quedado muchas cosas en el tintero pero dada la filosofía de este libro, proporcionarte recursos, se nos hace imposible entrar más en detalle sobre todo lo que puedes realizar con las API’s de Google. Desde aquí queremos indicarte una serie de URLs que nos son de gran utilidad para trabajar con los servicios de Google:


Recursos:

http://code.google.com/intl/es/apis/maps/documentation/reference.html

Esta página es el manual de referencia de las API de Google. Encontrarás todas las clases, con sus atributos y métodos. Se trata de un recurso esencial.

http://code.google.com/intl/es/

Desde aquí podrá acceder a la todas las secciones de los desarrolladores.

http://code.google.com/intl/es/apis/maps/documentation/

Documentación específica para la API de Maps, con un montón de ejemplos.

http://www.desarrolloweb.com/manuales/desarrollo-con-api-de-google-maps.html

Manual del API de Google Map del portal DesarrolloWeb.